package com.woohua.demo.calc;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;

import java.math.BigDecimal;
import java.util.*;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 公式解析引擎
 * <p>
 *
 * @author songzhaoying@com.
 * @date 2020/8/11 14:44.
 */
@Slf4j
public class CalculatorUtil {


    /**
     * 表达式字符合法性校验正则模式
     */
    private static final String EXPRESSION_PATTERN_REGEX = "^[0-9][\\+\\-\\*/][()]+$";

    /**
     * 判断数字正则
     */
    private static final String NUM_REGEX = "\\d+(\\.)?\\d*((E|e|E\\+|e\\+|E-|e-)\\d+)?";

    /**
     * 操作符 需要加 空格
     * ((|)|+|-|*|/|_|%)
     */
    private static final String ADD_SPACE_REGEX = "((\\d+.?\\d*[Ee]([+\\-])?\\d+)|([()+\\-*/_%]))";

    /**
     * 空格
     */
    private static final String SPACE = "\\s";

    /**
     * 计算中保留小数位数
     */
    private static final int CAL_SCALE_SIZE = 10;

    /**
     * 计算中保留小数位数 处理原则
     */
    private static final int CAL_SCALE_ROUND = BigDecimal.ROUND_HALF_DOWN;

    /**
     * 保留小数
     *
     * @param calExpressionStr
     * @param scaleSize
     * @param bigRoundType
     * @return
     * @throws Exception
     */
    public static BigDecimal executeExpression(String calExpressionStr, int scaleSize, int bigRoundType) throws Exception {
        return executeExpression(calExpressionStr).setScale(scaleSize, bigRoundType);
    }

    /**
     * 计算值 10 位小数 0 去掉
     *
     * @param calExpressionStr
     * @return
     * @throws Exception
     */
    public static BigDecimal executeExpression(String calExpressionStr) throws Exception {
        return new BigDecimal(calculate(calExpressionStr).stripTrailingZeros().toPlainString());
    }

    /**
     * 计算 中序 字符串
     *
     * @param calExpressionStr
     * @return
     */
    public static BigDecimal calculate(String calExpressionStr) throws Exception {
        calExpressionStr = check2RepairExpression(calExpressionStr);

        List<String> inorderExpressionList = getInorderExpressionList(calExpressionStr);

        // 生成 逆波兰 表达式 list
        List<String> suffixExpressionList = getSuffixExpressionList(inorderExpressionList);

        if (log.isDebugEnabled()) {
            log.info("中序表达式：{}", JSON.toJSONString(inorderExpressionList));
            log.info("后缀表达式：{}", JSON.toJSONString(suffixExpressionList));
        }

        return calculate(suffixExpressionList);
    }

    /**
     * 生成中序表达式 list
     *
     * @param calExpressionStr
     * @return
     */
    private static List<String> getInorderExpressionList(String calExpressionStr) {
        // 生成 中序表达式 list
        return Arrays.stream(calExpressionStr.split(SPACE))
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toList());
    }

    /**
     * 计算 逆波兰 / 后序表达式 List
     *
     * @param suffixExpressionList
     * @return
     */
    private static BigDecimal calculate(List<String> suffixExpressionList) throws Exception {
        if (CollectionUtils.isEmpty(suffixExpressionList)) {
            return BigDecimal.ZERO;
        }

        Stack<BigDecimal> numStack = new Stack<>();

        for (String op2num : suffixExpressionList) {
            if (StringUtils.isBlank(op2num)) {
                continue;
            }
            // 使用正则表达式取出
            if (isNumber(op2num)) {
                // 数字
                numStack.push(new BigDecimal(op2num));
            } else {
                // 运算符
                OptEnum opEnum = OptEnum.getEnum(op2num);
                if (opEnum.getCalFunction() == null) {
                    throw new RuntimeException("操作符不支持！");
                }

                BigDecimal bigDecimal2 = numStack.pop();
                BigDecimal bigDecimal1 = numStack.pop();

                BigDecimal resultBigDecimal = opEnum.getCalFunction().apply(bigDecimal1, bigDecimal2);

                // 结果入栈
                numStack.push(resultBigDecimal);
            }
        }

        return numStack.pop();
    }

    /**
     * 生成逆波兰 / 后续表达式 list
     *
     * @param inorderExpressionList
     * @return
     */
    private static List<String> getSuffixExpressionList(List<String> inorderExpressionList) {
        Stack<String> opStack = new Stack<>();

        // 不通过中间栈，在进行逆序处理，直接输出到list中，就是需要的逆波兰表达式
        List<String> resList = new ArrayList<>(inorderExpressionList.size());
        for (String op2num : inorderExpressionList) {
            if (isNumber(op2num)) {
                // 数字
                resList.add(op2num);
            } else if (Objects.equals(op2num, OptEnum.OP_LEFT_BRACKET.getOpt())) {
                // (
                opStack.push(op2num);
            } else if (Objects.equals(op2num, OptEnum.OP_RIGHT_BRACKET.getOpt())) {
                // )
                while (!opStack.peek().equals(OptEnum.OP_LEFT_BRACKET.getOpt())) {
                    resList.add(opStack.pop());
                }
                // 去掉 (
                opStack.pop();
            } else {
                // 操作符 优先级
                while (!CollectionUtils.isEmpty(opStack)
                        && OptEnum.getEnum(opStack.peek()).getOptPriority() >= OptEnum.getEnum(op2num).getOptPriority()) {
                    resList.add(opStack.pop());
                }
                // 将 操作符 最后加入
                opStack.push(op2num);
            }
        }

        // 处理剩余的操作符
        while (!CollectionUtils.isEmpty(opStack)) {
            resList.add(opStack.pop());
        }

        return resList;
    }

    /**
     * 判断是否数字
     *
     * @param numberStr
     * @return
     */
    public static boolean isNumber(String numberStr) {
        if (numberStr == null) {
            return false;
        }
        return numberStr.matches(NUM_REGEX);
    }

    /**
     * 运算符 枚举
     */
    public enum OptEnum {
        /**
         * 运算符
         */
        OP_LEFT_BRACKET("(", "左括号", 0, null),
        OP_RIGHT_BRACKET(")", "右括号", 7, null),

        OP_ADD("+", "加", 2, (p1, p2) -> p1.add(p2)),
        OP_SUB("-", "减", 2, (p1, p2) -> p1.subtract(p2)),
        OP_MULTIPLY("*", "乘", 3, (p1, p2) -> p1.multiply(p2)),
        OP_DIVIDE("/", "除", 3, (p1, p2) -> p1.divide(p2, CAL_SCALE_SIZE, CAL_SCALE_ROUND)),

        OP_FLOOR("_", "取整", 3, (p1, p2) -> p1.divide(p2, 0, BigDecimal.ROUND_DOWN)),
        OP_MODE("%", "取模", 3, (p1, p2) -> p1.divideAndRemainder(p2)[1]),

        ;

        /**
         * 运算符
         */
        private String opt;

        /**
         * 运算说明
         */
        private String optName;

        /**
         * 运算级别
         */
        private Integer optPriority;

        /**
         * 运算 函数
         */
        private BiFunction<BigDecimal, BigDecimal, BigDecimal> calFunction;

        /**
         * @param opt
         * @param optName
         * @param optPriority
         * @param biFunction
         */
        OptEnum(String opt, String optName, Integer optPriority
                , BiFunction<BigDecimal, BigDecimal, BigDecimal> biFunction) {
            this.opt = opt;
            this.optName = optName;
            this.optPriority = optPriority;
            this.calFunction = biFunction;
        }

        /**
         * 取枚举
         *
         * @param opt
         * @return
         */
        protected static OptEnum getEnum(String opt) {
            return Stream.of(OptEnum.values())
                    .filter(t -> Objects.equals(opt, t.getOpt()))
                    .findFirst().orElseThrow(() -> new RuntimeException("运算符不支持"));
        }

        public String getOpt() {
            return opt;
        }

        public String getOptName() {
            return optName;
        }

        public Integer getOptPriority() {
            return optPriority;
        }

        public BiFunction<BigDecimal, BigDecimal, BigDecimal> getCalFunction() {
            return calFunction;
        }
    }

    /**
     * 校验 & 整理字符串
     * 科学计数处理
     *
     * @param calExpressionStr
     * @return
     */
    private static String check2RepairExpression(String calExpressionStr) {
        // 非空校验
        if (StringUtils.isBlank(calExpressionStr)) {
            throw new IllegalArgumentException("表达式不能为空！");
        }

        // 表达式字符合法性校验
        if (!calExpressionStr.matches(EXPRESSION_PATTERN_REGEX)) {
            throw new IllegalArgumentException("表达式含有非法字符！" + calExpressionStr);
        }

        // 整理字符串
        calExpressionStr = calExpressionStr.replaceAll(SPACE, "");

        // (- 替换为 (0-
        calExpressionStr = calExpressionStr.replace(OptEnum.OP_LEFT_BRACKET.getOpt() + OptEnum.OP_SUB.getOpt()
                , OptEnum.OP_LEFT_BRACKET.getOpt() + BigDecimal.ZERO + OptEnum.OP_SUB.getOpt());

        // - 开始 前缀 0-
        if (calExpressionStr.startsWith(OptEnum.OP_SUB.getOpt())) {
            calExpressionStr = BigDecimal.ZERO + calExpressionStr;
        }

        calExpressionStr = calExpressionStr.replaceAll(ADD_SPACE_REGEX, " $1 ").trim();

        if (log.isDebugEnabled()) {
            log.info("整理后的运算串：{}", calExpressionStr);
        }

        return calExpressionStr;
    }


    public static void main(String[] args) throws Exception {
        String str = "3.E+3 \n* 2";
        boolean number = isNumber("3.E+3");

        BigDecimal bigDecimal = executeExpression(str);

        System.out.println(bigDecimal);

        System.out.println(executeExpression("-1 + (-1) + 2"));
        System.out.println(executeExpression(" 2 + 13/3 * 3 - 4 *(2 + 5 -2*4/2+9) + 3 + (2*1)-3"));
        System.out.println(executeExpression("330000000000*121000000000000000000000000000"
                , 4, BigDecimal.ROUND_HALF_UP));

        System.out.println(executeExpression("9.2 *(20-1)-1+199 / 13"
                , 4, BigDecimal.ROUND_HALF_UP));
        System.out.println(executeExpression("9.2 *(20-1)-1+199 / 13"));
        System.out.println(executeExpression("11"));
    }
}
